home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 426-450 / disk_438 / gadgeted / source / bin.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  18KB  |  609 lines
  1. /*----------------------------------------------------------------------*
  2.    bin.c Version 2.0 -  © Copyright 1990 Jaba Development
  3.  
  4.    Author : Jan van den Baard
  5.    Purpose: The reading and writing of the gadgets in binary form.
  6.  *----------------------------------------------------------------------*/
  7.  
  8. /*
  9.  * external global data
  10.  */
  11. extern struct Screen        *MainScreen;
  12. extern struct Window        *MainWindow;
  13. extern struct GadgetList     Gadgets;
  14. extern struct NewWindow      nw_main;
  15. extern struct Gadget         TextGadget;
  16. extern struct ge_prefs       prefs;
  17. extern struct FileRequester *IODir;
  18. extern struct MemoryChain    Misc;
  19. extern struct MemoryChain    Memory;
  20. extern USHORT                GadgetCount, id, BackFill;
  21. extern USHORT                FrontPen, BackPen, Colors[];
  22. extern BOOL                  Saved, REQUESTER, WBSCREEN;
  23. extern UBYTE                 name[512], wdt[80], wlb[MAXLABEL];
  24. extern ULONG                 WindowFlags, IDCMPFlags;
  25.  
  26. /*
  27.  * icon image data
  28.  */
  29. USHORT data[] =
  30.  { 0x0000,0x0000,0x0000,0x03fe,0x47ff,0xf800,0x0f01,0xc1e0,
  31.    0x1800,0x1e00,0xc1e0,0x0800,0x1c00,0x41e0,0x0800,0x3c00,
  32.    0x01e0,0x8000,0x3c00,0x01e1,0x8000,0x3c00,0x01ff,0x8000,
  33.    0x3c1f,0xe1e1,0x8000,0x3c07,0xc1e0,0x8000,0x3c03,0xc1e0,
  34.    0x0800,0x1e03,0xc1e0,0x0800,0x0f07,0xc1e0,0x1800,0x03fe,
  35.    0x67ff,0xf800,0x0000,0x0000,0x0000,0xffff,0xffff,0xfe00,
  36.    0xffff,0xffff,0xfe00,0xffff,0xffff,0xfe00,0xffff,0xffff,
  37.    0xfe00,0xffff,0xffff,0xfe00,0xffff,0xffff,0xfe00,0xffff,
  38.    0xffff,0xfe00,0xffff,0xffff,0xfe00,0xffff,0xffff,0xfe00,
  39.    0xffff,0xffff,0xfe00,0xffff,0xffff,0xfe00,0xffff,0xffff,
  40.    0xfe00,0xffff,0xffff,0xfe00,0xffff,0xffff,0xfe00,0xffff,
  41.    0xffff,0xfe00
  42.  };
  43.  
  44. struct Image icon_image =
  45.  { 0,0,39,15,2,NULL,0x03,0x00,NULL };
  46. struct IconBase *IconBase;
  47.  
  48. /*
  49.  * write a 'GE' icon
  50.  */
  51. BOOL write_icon(nme)
  52.     UBYTE *nme;
  53. {
  54.     struct DiskObject  icon;
  55.     struct Gadget      icon_Gadget;
  56.     BOOL               ret;
  57.  
  58.     if((IconBase = OpenLibrary(ICONNAME,0L)))
  59.     {   icon_image.ImageData     =   &data[0];
  60.  
  61.         icon_Gadget.NextGadget   =   NULL;
  62.         icon_Gadget.LeftEdge     =   0;
  63.         icon_Gadget.TopEdge      =   0;
  64.         icon_Gadget.Width        =   39;
  65.         icon_Gadget.Height       =   15;
  66.         icon_Gadget.Flags        =   GADGIMAGE+GADGBACKFILL;
  67.         icon_Gadget.Activation   =   RELVERIFY+GADGIMMEDIATE;
  68.         icon_Gadget.GadgetType   =   BOOLGADGET;
  69.         icon_Gadget.GadgetRender =   (APTR)&icon_image;
  70.         icon_Gadget.SelectRender =   NULL;
  71.         icon_Gadget.GadgetText   =   NULL;
  72.         icon_Gadget.MutualExclude=   NULL;
  73.         icon_Gadget.SpecialInfo  =   NULL;
  74.         icon_Gadget.GadgetID     =   NULL;
  75.         icon_Gadget.UserData     =   NULL;
  76.  
  77.         icon.do_Magic            =   WB_DISKMAGIC;
  78.         icon.do_Version          =   WB_DISKVERSION;
  79.         icon.do_Gadget           =   icon_Gadget;
  80.         icon.do_Type             =   WBPROJECT;
  81.         icon.do_DefaultTool      =   (char *)":GadgetEd";
  82.         icon.do_ToolTypes        =   NULL;
  83.         icon.do_CurrentX         =   NO_ICON_POSITION;
  84.         icon.do_CurrentY         =   NO_ICON_POSITION;
  85.         icon.do_DrawerData       =   NULL;
  86.         icon.do_ToolWindow       =   NULL;
  87.         icon.do_StackSize        =   NULL;
  88.         ret = PutDiskObject((char *)nme,&icon);
  89.  
  90.         CloseLibrary(IconBase);
  91.         if(NOT ret) return(FALSE);
  92.         return(TRUE);
  93.     }
  94.     return(FALSE);
  95. }
  96.  
  97. /*
  98.  * write a gadget
  99.  */
  100. static BOOL WBG(file,g)
  101.     BPTR               file;
  102.     struct MyGadget   *g;
  103. {
  104.     struct Gadget     *gadget;
  105.     struct IntuiText  *t;
  106.     struct Border     *b;
  107.     struct Image      *i;
  108.     struct StringInfo *s;
  109.     ULONG              data_size;
  110.     char              *str;
  111.  
  112.     gadget = &g->Gadget;
  113.  
  114.     Write(file,(char *)gadget,sizeof(struct Gadget));
  115.     Write(file,(char *)&g->SpecialFlags,2);
  116.     Write(file,(char *)&g->GadgetLabel,MAXLABEL);
  117.  
  118.     if((t = gadget->GadgetText))
  119.     {   while(1)
  120.         {   Write(file,(char *)t,sizeof(struct IntuiText));
  121.             Write(file,(char *)t->IText,80);
  122.             if(NOT(t = t->NextText)) break;
  123.         }
  124.     }
  125.     if((NOT TestBits((ULONG)gadget->GadgetType,PROPGADGET)) AND
  126.        (NOT TestBits((ULONG)gadget->Flags,GADGIMAGE)))
  127.     {   b = (struct Border *)gadget->GadgetRender;
  128.         Write(file,(char *)b,sizeof(struct Border));
  129.         Write(file,(char *)b->XY,20);
  130.     }
  131.     else if(TestBits((ULONG)gadget->Flags,GADGIMAGE))
  132.     {   i = (struct Image *)gadget->GadgetRender;
  133.         data_size = (ULONG)(RASSIZE(i->Width,i->Height) * i->Depth);
  134.         Write(file,(char *)i,sizeof(struct Image));
  135.         Write(file,(char *)i->ImageData,data_size);
  136.     }
  137.  
  138.     if((TestBits((ULONG)gadget->Flags,GADGHIMAGE)) AND
  139.        (NOT TestBits((ULONG)gadget->Flags,GADGHBOX)))
  140.     {   i = (struct Image *)gadget->SelectRender;
  141.         data_size = (ULONG)(RASSIZE(i->Width,i->Height) * i->Depth);
  142.         Write(file,(char *)i,sizeof(struct Image));
  143.         Write(file,(char *)i->ImageData,data_size);
  144.     }
  145.  
  146.     if(TestBits((ULONG)gadget->GadgetType,PROPGADGET))
  147.     {   Write(file,(char *)gadget->SpecialInfo,sizeof(struct PropInfo));
  148.     }
  149.     if(TestBits((ULONG)gadget->GadgetType,STRGADGET))
  150.     {   s = (struct StringInfo *)gadget->SpecialInfo;
  151.         Write(file,(char *)s,sizeof(struct StringInfo));
  152.         Write(file,(char *)s->Buffer,s->MaxChars);
  153.     }
  154.     if(str = IoErrToStr())
  155.     {   enable_window();
  156.         Error(str);
  157.         return(FALSE); }
  158.     return(TRUE);
  159. }
  160.  
  161. /*
  162.  * write the window/requester texts (if there are any)
  163.  */
  164. static BOOL WriteWRTexts(file)
  165.     BPTR file;
  166. {
  167.     register struct IntuiText *t;
  168.     char    *str;
  169.  
  170.     if((t = TextGadget.GadgetText))
  171.     {   while(1)
  172.         {   Write(file,(char *)t,sizeof(struct IntuiText));
  173.             Write(file,(char *)t->IText,80);
  174.             if(NOT(t = t->NextText)) break;
  175.         }
  176.     }
  177.     if(str = IoErrToStr())
  178.     {   enable_window();
  179.         Error(str);
  180.         return(FALSE);
  181.     }
  182.     return(TRUE);
  183. }
  184.  
  185. /*
  186.  * read a gadget
  187.  */
  188. static BOOL RBG(file)
  189.     BPTR file;
  190. {
  191.     struct MyGadget   *g;
  192.     struct Gadget     *gadget;
  193.     struct IntuiText  *t,*t1;
  194.     struct Border     *b;
  195.     struct Image      *i;
  196.     struct StringInfo *s;
  197.     ULONG  data_size;
  198.     char    *str;
  199.  
  200.  
  201.     if(NOT(g = (struct MyGadget *)Alloc(&Memory,(ULONG)sizeof(struct MyGadget))))
  202.         goto NoMem;
  203.  
  204.     AddTail((void *)&Gadgets,(void *)g);
  205.  
  206.     gadget = (struct Gadget *)&g->Gadget;
  207.  
  208.     Read(file,(char *)gadget,sizeof(struct Gadget));
  209.     Read(file,(char *)&g->SpecialFlags,2);
  210.     Read(file,(char *)&g->GadgetLabel,MAXLABEL);
  211.  
  212.     if(gadget->GadgetText)
  213.     {   if(NOT(t1 = (struct IntuiText *)
  214.          Alloc(&Memory,(ULONG)sizeof(struct IntuiText))))
  215.             goto NoMem;
  216.         Read(file,(char *)t1,sizeof(struct IntuiText));
  217.  
  218.         if(NOT(t1->IText = (UBYTE *)Alloc(&Memory,80L)))
  219.             goto NoMem;
  220.         Read(file,(char *)t1->IText,80);
  221.         gadget->GadgetText = t1;
  222.         if(t1->NextText)
  223.         {   while(1)
  224.             {   if(NOT(t = (struct IntuiText *)
  225.                  Alloc(&Memory,(ULONG)sizeof(struct IntuiText))))
  226.                     goto NoMem;
  227.                 Read(file,(char *)t,sizeof(struct IntuiText));
  228.  
  229.                 if(NOT(t->IText = (UBYTE *)Alloc(&Memory,80L)))
  230.                     goto NoMem;
  231.                 Read(file,(char *)t->IText,80);
  232.                 t1->NextText = t;
  233.                 if(NOT t->NextText) break;
  234.                 t1 = t;
  235.             }
  236.         }
  237.     }
  238.  
  239.     if((NOT TestBits((ULONG)gadget->GadgetType,PROPGADGET)) AND
  240.        (NOT TestBits((ULONG)gadget->Flags,GADGIMAGE)))
  241.     {   if(NOT(b = (struct Border *)
  242.          Alloc(&Memory,(ULONG)sizeof(struct Border))))
  243.             goto NoMem;
  244.         Read(file,(char *)b,sizeof(struct Border));
  245.  
  246.         if(NOT(b->XY = (SHORT *)Alloc(&Memory,20L)))
  247.             goto NoMem;
  248.         Read(file,(char *)b->XY,20);
  249.         gadget->GadgetRender = (APTR)b;
  250.     }
  251.     else if(TestBits((ULONG)gadget->Flags,GADGIMAGE))
  252.     {   if(NOT(i = (struct Image *)
  253.          Alloc(&Memory,(ULONG)sizeof(struct Image))))
  254.             goto NoMem;
  255.         Read(file,(char *)i,sizeof(struct Image));
  256.  
  257.         data_size = (ULONG)(RASSIZE(i->Width,i->Height) * i->Depth);
  258.         if(NOT(i->ImageData = (USHORT *)
  259.          AllocMem(data_size,MEMF_CHIP+MEMF_CLEAR)))
  260.             goto NoMem;
  261.         Read(file,(char *)i->ImageData,data_size);
  262.         gadget->GadgetRender = (APTR)i;
  263.     }
  264.  
  265.     if((TestBits((ULONG)gadget->Flags,GADGHIMAGE)) AND
  266.        (NOT TestBits((ULONG)gadget->Flags,GADGHBOX)))
  267.     {   if(NOT(i = (struct Image *)
  268.          Alloc(&Memory,(ULONG)sizeof(struct Image))))
  269.             goto NoMem;
  270.         Read(file,(char *)i,sizeof(struct Image));
  271.  
  272.         data_size = (ULONG)(RASSIZE(i->Width,i->Height) * i->Depth);
  273.         if(NOT(i->ImageData = (USHORT *)
  274.          AllocMem(data_size,MEMF_CHIP+MEMF_CLEAR)))
  275.             goto NoMem;
  276.         Read(file,(char *)i->ImageData,data_size);
  277.         gadget->SelectRender = (APTR)i;
  278.     }
  279.  
  280.     if(TestBits((ULONG)gadget->GadgetType,PROPGADGET))
  281.     {   if(NOT TestBits((ULONG)gadget->Flags,GADGIMAGE))
  282.         {   if(NOT(gadget->GadgetRender =
  283.              Alloc(&Memory,(ULONG)sizeof(struct Image))))
  284.                 goto NoMem;
  285.         }
  286.         if(NOT(gadget->SpecialInfo =
  287.           Alloc(&Memory,(ULONG)sizeof(struct PropInfo))))
  288.                 goto NoMem;
  289.         Read(file,(char *)gadget->SpecialInfo,sizeof(struct PropInfo));
  290.     }
  291.     if(TestBits((ULONG)gadget->GadgetType,STRGADGET))
  292.     {   if(NOT(s = (struct StringInfo *)
  293.          Alloc(&Memory,(ULONG)sizeof(struct StringInfo))))
  294.             goto NoMem;
  295.         Read(file,(char *)s,sizeof(struct StringInfo));
  296.         if(NOT(s->Buffer = (UBYTE *)Alloc(&Memory,s->MaxChars)))
  297.             goto NoMem;
  298.         Read(file,(char *)s->Buffer,s->MaxChars);
  299.         if(s->UndoBuffer)
  300.         {   if(NOT(s->UndoBuffer = (UBYTE *)Alloc(&Memory,s->MaxChars)))
  301.                 goto NoMem;
  302.         }
  303.         gadget->SpecialInfo = (APTR)s;
  304.     }
  305.     if(str = IoErrToStr())
  306.     {   enable_window();
  307.         Error(str);
  308.         return(FALSE);
  309.     }
  310.     return(TRUE);
  311.  
  312. NoMem:
  313.     enable_window();
  314.     Error("Out of Memory !");
  315.     return(FALSE);
  316. }
  317.  
  318. /*
  319.  * read the window/requester text (if there are any)
  320.  */
  321. static BOOL ReadWRTexts(file,num)
  322.     BPTR file;
  323.     ULONG num;
  324. {
  325.     register struct IntuiText *t, *t1;
  326.     register UCOUNT i;
  327.     char    *str;
  328.  
  329.     if(NOT num) return(TRUE);
  330.  
  331.     if(NOT(t = (struct IntuiText *)
  332.      Alloc(&Memory,(ULONG)sizeof(struct IntuiText))))
  333.         goto NoMem;
  334.     Read(file,(char *)t,sizeof(struct IntuiText));
  335.     if(NOT(t->IText = (UBYTE *)Alloc(&Memory,80L)))
  336.         goto NoMem;
  337.     Read(file,(char *)t->IText,80);
  338.     TextGadget.GadgetText = t;
  339.     for(i=0;i<num-1;i++)
  340.     {   if(NOT(t1 = (struct IntuiText *)
  341.          Alloc(&Memory,(ULONG)sizeof(struct IntuiText))))
  342.             goto NoMem;
  343.         Read(file,(char *)t1,sizeof(struct IntuiText));
  344.         if(NOT(t1->IText = (UBYTE *)Alloc(&Memory,80)))
  345.             goto NoMem;
  346.         Read(file,(char *)t1->IText,80);
  347.         t->NextText = t1;
  348.         t = t1;
  349.     }
  350.     if(str = IoErrToStr())
  351.     {   enable_window();
  352.         Error(str);
  353.         return(FALSE);
  354.     }
  355.     return(TRUE);
  356.  
  357. NoMem:
  358.     enable_window();
  359.     Error("Out of Memory !");
  360.     return(FALSE);
  361. }
  362.  
  363. /*
  364.  * get the number of window/requester texts
  365.  */
  366. static LONG get_num_texts()
  367. {
  368.     register struct IntuiText *t;
  369.     LONG num = NULL;
  370.  
  371.     if((t = TextGadget.GadgetText))
  372.     {   num = 1L;
  373.         while(1)
  374.         {   if(NOT(t = t->NextText)) break;
  375.             num++;
  376.         }
  377.     }
  378.     return(num);
  379. }
  380.  
  381. /*
  382.  * write a binary gadgets file
  383.  */
  384. VOID WriteBinGadgets()
  385. {
  386.     struct BinHeader         head;
  387.     BPTR                     file;
  388.     struct ViewPort          *vp;
  389.     ULONG                    rc;
  390.     struct NewWindow         nw;
  391.     register struct MyGadget *g;
  392.     register UCOUNT          i;
  393.     char    *str;
  394.  
  395.     strcpy((char *)IODir->fr_HeadLine,(char *)"Save Binary");
  396.  
  397.     IODir->fr_Screen = MainScreen;
  398.     IODir->fr_Caller = MainWindow;
  399.     rc = FileRequest(IODir);
  400.     if(rc == FREQ_CANCELED) return;
  401.     else if(rc)
  402.     {   Error("FileRequester won't open !");
  403.         return;
  404.     }
  405.     strcpy((char *)&name,(char *)IODir->fr_DirName);
  406.     strcat((char *)&name,(char *)IODir->fr_FileName);
  407.  
  408.     disable_window();
  409.     SetWindowTitles(MainWindow,(char *)-1L,(char *)"Saving Binary......");
  410.     buisy();
  411.     vp = &MainScreen->ViewPort;
  412.  
  413.     if(NOT(file = Open((char *)&name,MODE_NEWFILE)))
  414.     {   enable_window();
  415.         Error("Can't open Write File !");
  416.         return;
  417.     }
  418.     /* write file header */
  419.     head.FileType  = TYPE;
  420.     head.NumGads   = GadgetCount;
  421.     head.ReqGads   = REQUESTER;
  422.     head.WBScreen  = WBSCREEN;
  423.     head.ScrDepth  = MainScreen->BitMap.Depth;
  424.     for(i=0;i<32;i++) head.Colors[i] = (USHORT)GetRGB4(vp->ColorMap,(LONG)i);
  425.     head.NumTexts  = get_num_texts();
  426.     Write(file,(char *)&head,sizeof(struct BinHeader));
  427.  
  428.     /* write prefs */
  429.     Write(file,(char *)&prefs,sizeof(struct ge_prefs));
  430.  
  431.     /* write window specifics */
  432.     nw.LeftEdge    = MainWindow->LeftEdge;
  433.     nw.TopEdge     = MainWindow->TopEdge;
  434.     nw.Width       = MainWindow->Width;
  435.     nw.Height      = MainWindow->Height;
  436.     nw.DetailPen   = MainWindow->DetailPen;
  437.     if(REQUESTER)  nw.BlockPen = BackFill;
  438.     else           nw.BlockPen = MainWindow->BlockPen;
  439.     nw.Flags       = WindowFlags;
  440.     nw.IDCMPFlags  = IDCMPFlags;
  441.     nw.FirstGadget = NULL;
  442.     nw.CheckMark   = NULL;
  443.     nw.Title       = NULL;
  444.     nw.Screen      = NULL;
  445.     nw.BitMap      = NULL;
  446.     nw.MinWidth    = MainWindow->MinWidth;
  447.     nw.MinHeight   = MainWindow->MinHeight;
  448.     nw.MaxWidth    = MainWindow->MaxWidth;
  449.     nw.MaxHeight   = MainWindow->MaxHeight;
  450.     nw.Type        = CUSTOMSCREEN;
  451.     Write(file,(char *)&nw,sizeof(struct NewWindow));
  452.  
  453.     /* write title + label */
  454.     Write(file,(char *)&wdt,80);
  455.     Write(file,(char *)&wlb,MAXLABEL);
  456.  
  457.     /* write window/requester texts */
  458.     if(WriteWRTexts(file) == FALSE)
  459.     {   Close(file);
  460.         return;
  461.     }
  462.  
  463.     if(GadgetCount)
  464.     {   for(g = Gadgets.Head; g != (struct MyGadget *)&Gadgets.Tail; g = g->Succ)
  465.         {   if(WBG(file,g) == FALSE)
  466.             {   Close(file);
  467.                 return;
  468.             }
  469.         }
  470.     }
  471.     Close(file);
  472.     if(str = IoErrToStr())
  473.     {   enable_window();
  474.         Error(str);
  475.         DeleteFile((char *)&name[0]);
  476.         return;
  477.     }
  478.     Saved = TRUE;
  479.     if(NOT(write_icon((char *)&name[0])))
  480.         Error("Error writing the icon");
  481.     enable_window();
  482.     ok();
  483. }
  484.  
  485. /*
  486.  * read a binary gadgets file
  487.  */
  488. VOID ReadBinGadgets(fsu)
  489.     BOOL fsu;
  490. {
  491.     struct BinHeader         head;
  492.     BPTR                     file;
  493.     struct ViewPort          *vp;
  494.     ULONG                    rc;
  495.     register struct MyGadget *g;
  496.     register UCOUNT          i;
  497.     char   *str;
  498.  
  499.     if(NOT fsu)
  500.     {   if(Saved == FALSE)
  501.         {   if(Ask("Current work isn't saved !",
  502.                    "Load a file anyway ?") == FALSE) return;
  503.         }
  504.         strcpy((char *)IODir->fr_HeadLine,(char *)"Load Binary");
  505.         IODir->fr_Screen = MainScreen;
  506.         IODir->fr_Caller = MainWindow;
  507.         rc = FileRequest(IODir);
  508.         if(rc == FREQ_CANCELED) return;
  509.         else if(rc)
  510.         {   Error("FileRequester won't open !");
  511.             return;
  512.         }
  513.         strcpy((char *)&name,(char *)IODir->fr_DirName);
  514.         strcat((char *)&name,(char *)IODir->fr_FileName);
  515.     }
  516.  
  517.     if(NOT(file = Open((char *)&name,MODE_OLDFILE)))
  518.     {   if(fsu)
  519.         {   change_depth(2);
  520.             LoadRGB4(&MainScreen->ViewPort,&Colors[0],4);
  521.         }
  522.         Error("Can't open Read File !");
  523.         return;
  524.     }
  525.  
  526.     Read(file,(char *)&head,sizeof(struct BinHeader));
  527.  
  528.     if(head.FileType != TYPE)
  529.     {   if(fsu)
  530.         {   change_depth(2);
  531.             LoadRGB4(&MainScreen->ViewPort,&Colors[0],4);
  532.         }
  533.         Close(file);
  534.         Error("Unknown FileType !"); return;
  535.     }
  536.  
  537.     FreeGList();
  538.     GadgetCount = id = 0;
  539.  
  540.     REQUESTER = head.ReqGads;
  541.     WBSCREEN  = head.WBScreen;
  542.  
  543.     Read(file,(char *)&prefs,sizeof(struct ge_prefs));
  544.     Read(file,(char *)&nw_main,sizeof(struct NewWindow));
  545.  
  546.     WindowFlags = nw_main.Flags;
  547.     IDCMPFlags  = nw_main.IDCMPFlags;
  548.  
  549.     if(REQUESTER)
  550.     {   BackFill = nw_main.BlockPen;
  551.         BackPen  = 1;
  552.         FrontPen = 0;
  553.         nw_main.DetailPen = 0;
  554.         nw_main.BlockPen  = 1;
  555.         nw_main.Flags     = WINDOWDRAG|WINDOWSIZING;
  556.         nw_main.Flags    |= GIMMEZEROZERO|SIZEBRIGHT|SIZEBBOTTOM|BORDERLESS;
  557.     }
  558.     else
  559.     {   nw_main.Flags     = 0;
  560.         BackPen  = 0;
  561.         FrontPen = 1;
  562.         if(TestBits(WindowFlags,WINDOWCLOSE))   nw_main.Flags |= WINDOWCLOSE;
  563.         if(TestBits(WindowFlags,WINDOWDEPTH))   nw_main.Flags |= WINDOWDEPTH;
  564.         if(TestBits(WindowFlags,WINDOWDRAG))    nw_main.Flags |= WINDOWDRAG;
  565.         if(TestBits(WindowFlags,WINDOWSIZING))  nw_main.Flags |= WINDOWSIZING;
  566.         if(TestBits(WindowFlags,SIZEBRIGHT))    nw_main.Flags |= SIZEBRIGHT;
  567.         if(TestBits(WindowFlags,SIZEBBOTTOM))   nw_main.Flags |= SIZEBBOTTOM;
  568.     }
  569.     nw_main.Flags      |=SMART_REFRESH|NOCAREREFRESH|ACTIVATE;
  570.     nw_main.IDCMPFlags  =SIZEVERIFY|NEWSIZE|GADGETUP|GADGETDOWN|INACTIVEWINDOW;
  571.     nw_main.IDCMPFlags |=ACTIVEWINDOW|MENUPICK|RAWKEY|MOUSEBUTTONS|CLOSEWINDOW;
  572.  
  573.     Read(file,(char *)&wdt,80);
  574.     Read(file,(char *)&wlb,MAXLABEL);
  575.  
  576.     change_depth(head.ScrDepth);
  577.     disable_window();
  578.     SetWindowTitles(MainWindow,(char *)-1L,(char *)"Reading Binary......");
  579.     buisy();
  580.     vp = &MainScreen->ViewPort;
  581.     LoadRGB4(vp,(void *)&head.Colors,(1 << MainScreen->BitMap.Depth));
  582.     if(ReadWRTexts(file,head.NumTexts) == FALSE)
  583.     {   Close(file);
  584.         FreeGList();
  585.         return;
  586.     }
  587.     if(head.NumGads)
  588.     {   for(i=0;i<head.NumGads;i++)
  589.         {   if(RBG(file) == FALSE)
  590.             {   Close(file);
  591.                 FreeGList();
  592.                 return;
  593.             }
  594.         }
  595.         for(g = Gadgets.Head; g != (struct MyGadget *)&Gadgets.Tail; g = g->Succ)
  596.         {   AddGList(MainWindow,&g->Gadget,NULL,1,NULL);
  597.             GadgetCount++;
  598.             id++;
  599.         }
  600.     }
  601.     Close(file);
  602.     rem_bo();
  603.     refresh();
  604.     Saved = TRUE;
  605.     enable_window();
  606.     ok();
  607.     if(str = IoErrToStr()) Error(str);
  608. }
  609.